#pragma once

#include "NetworkManager.h"
#include "TcpChannel.h"
#include "KcpChannel.h"
#include <functional>
#include <memory>
#include <map>
#include <mutex>
#include <thread>
#include <vector>
#include <asio.hpp>

namespace SeanNetwork {

// 客户端会话ID类型
using ClientSessionId = uint64_t;

// 客户端会话连接信息
struct ClientSession {
    ClientSessionId Id;                   // 会话ID
    asio::ip::address Address;            // 客户端地址
    uint16_t Port;                        // 客户端端口
    ConnectionState State;                // 连接状态
    ChannelType CurrentChannel;           // 当前使用的通道
    std::shared_ptr<TcpChannel> TcpChannel;  // TCP通道
    std::shared_ptr<KcpChannel> KcpChannel;  // KCP通道
    uint64_t ConnectTime;                 // 连接建立时间（毫秒时间戳）
    uint64_t LastActiveTime;              // 最后活动时间（毫秒时间戳）
    
    ClientSession() : Id(0), Port(0), State(ConnectionState::Disconnected), 
                    CurrentChannel(ChannelType::KCP), ConnectTime(0), LastActiveTime(0) {}
};

// 消息处理回调函数类型
using ServerMessageHandler = std::function<void(ClientSessionId, std::shared_ptr<NetworkMessage>)>;

// 会话状态回调函数类型
using SessionStateCallback = std::function<void(ClientSessionId, ConnectionState, const std::string&)>;

// 网络服务器配置
struct ServerConfig : public NetworkConfig {
    uint16_t TcpPort;                  // TCP监听端口
    uint16_t KcpPort;                  // KCP监听端口
    uint32_t MaxConnections;           // 最大连接数
    uint32_t SessionTimeoutMs;         // 会话超时时间（毫秒）
    uint32_t SessionCheckInterval;     // 会话检查间隔（毫秒）
    
    ServerConfig() 
        : TcpPort(0), KcpPort(0), MaxConnections(1000), 
          SessionTimeoutMs(60000), SessionCheckInterval(5000) {}
};

// 网络服务器类
class NetworkServer {
public:
    NetworkServer();
    ~NetworkServer();
    
    // 初始化服务器
    bool Initialize(const ServerConfig& config);
    
    // 启动服务器
    bool Start();
    
    // 停止服务器
    void Stop();
    
    // 向指定客户端发送消息
    bool SendMsg(ClientSessionId clientId, std::shared_ptr<NetworkMessage> message);
    
    // 向所有客户端广播消息
    void BroadcastMessage(std::shared_ptr<NetworkMessage> message);
    
    // 断开指定客户端连接
    void DisconnectClient(ClientSessionId clientId);
    
    // 创建新消息
    std::shared_ptr<NetworkMessage> CreateMessage(uint32_t messageId, MessagePriority priority = MessagePriority::Normal);
    
    // 注册消息处理回调
    void RegisterMessageHandler(uint32_t messageId, ServerMessageHandler handler);
    
    // 设置会话状态回调
    void SetSessionCallback(SessionStateCallback callback);
    
    // 获取当前连接数
    size_t GetConnectionCount() const;
    
    // 获取客户端会话信息
    bool GetClientSession(ClientSessionId clientId, ClientSession& session) const;
    
    // 获取所有客户端会话ID
    std::vector<ClientSessionId> GetAllClientIds() const;
    
private:
    asio::io_context m_IoContext;
    std::unique_ptr<asio::io_context::work> m_Work;
    std::vector<std::thread> m_WorkerThreads;
    
    asio::ip::tcp::acceptor m_TcpAcceptor;
    asio::ip::udp::socket m_KcpSocket;
    
    std::map<ClientSessionId, ClientSession> m_ClientSessions;
    std::mutex m_SessionMutex;
    
    std::map<uint32_t, ServerMessageHandler> m_MessageHandlers;
    SessionStateCallback m_SessionCallback;
    
    std::unique_ptr<TimerManager> m_TimerManager;
    uint32_t m_SessionCheckTimerId;
    
    ServerConfig m_Config;
    std::atomic<bool> m_Running;
    std::atomic<ClientSessionId> m_NextSessionId;
    
    // 启动TCP监听
    bool StartTcpListener();
    
    // 启动KCP监听
    bool StartKcpListener();
    
    // 接受新的TCP连接
    void AcceptTcpConnection();
    
    // 处理TCP连接
    void HandleTcpAccept(const asio::error_code& ec, asio::ip::tcp::socket socket);
    
    // 接收KCP数据
    void ReceiveKcpData();
    
    // 处理KCP数据接收
    void HandleKcpReceive(const asio::error_code& ec, std::size_t bytes_transferred,
                        const asio::ip::udp::endpoint& sender,
                        std::shared_ptr<std::vector<uint8_t>> receiveBuffer);
    
    // 创建新的客户端会话
    ClientSessionId CreateClientSession(const asio::ip::address& clientAddress, uint16_t clientPort);
    
    // 移除客户端会话
    void RemoveClientSession(ClientSessionId sessionId);
    
    // 处理客户端消息
    void HandleClientMessage(ClientSessionId clientId, std::shared_ptr<NetworkMessage> message, ChannelType channel);
    
    // 处理客户端连接状态变更
    void HandleClientConnectionState(ClientSessionId clientId, ConnectionState state, 
                                   const std::string& reason, ChannelType channel);
    
    // 检查会话超时
    void CheckSessionTimeout();
    
    // 启动工作线程
    void StartWorkerThreads();
    
    // 停止工作线程
    void StopWorkerThreads();
    
    // 生成新的会话ID
    ClientSessionId GenerateSessionId();
    
    // 根据端点查找会话ID
    ClientSessionId FindSessionByEndpoint(const asio::ip::address& address, uint16_t port);
};

} // namespace SeanNetwork
